package com.linjiaxin.service;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.linjiaxin.pojo.BasePojo;
import org.springframework.beans.factory.annotation.Autowired;
import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.entity.Example;

import java.util.Date;
import java.util.List;

public abstract class BaseService<T extends BasePojo> {
/*	//根据实体类不为null的字段进行查询,条件全部使用=号and条件
	List<T> select(T record);

	//根据实体类不为null的字段查询总数,条件全部使用=号and条件
	int selectCount(T record);

	//根据主键进行查询,必须保证结果唯一
	//单个字段做主键时,可以直接写主键的值
	//联合主键时,key可以是实体类,也可以是Map
	T selectByPrimaryKey(Object key);

	//插入一条数据
	//支持Oracle序列,UUID,类似Mysql的INDENTITY自动增长(自动回写)
	//优先使用传入的参数值,参数值空时,才会使用序列、UUID,自动增长
	int insert(T record);

	//插入一条数据,只插入不为null的字段,不会影响有默认值的字段
	//支持Oracle序列,UUID,类似Mysql的INDENTITY自动增长(自动回写)
	//优先使用传入的参数值,参数值空时,才会使用序列、UUID,自动增长
	int insertSelective(T record);

	//根据实体类中字段不为null的条件进行删除,条件全部使用=号and条件
	int delete(T key);

	//通过主键进行删除,这里最多只会删除一条数据
	//单个字段做主键时,可以直接写主键的值
	//联合主键时,key可以是实体类,也可以是Map
	int deleteByPrimaryKey(Object key);

	//根据主键进行更新,这里最多只会更新一条数据
	//参数为实体类
	int updateByPrimaryKey(T record);

	//根据主键进行更新
	//只会更新不是null的数据
	int updateByPrimaryKeySelective(T record);*/
		
//	 public abstract Mapper<T> getMapper();
		@Autowired
		private Mapper<T> mapper;
	    /**
	     * 根据id查询数据
	     * 
	     * @param id
	     * @return
	     */
	    public T queryById(Long id) {
	        return this.mapper.selectByPrimaryKey(id);
	    }

	    /**
	     * 查询所有数据
	     * 
	     * @return
	     */
	    public List<T> queryAll() {
	        return this.mapper.select(null);
	    }

	    /**
	     * 根据条件查询一条数据，如果有多条数据会抛出异常
	     * 
	     * @param record
	     * @return
	     */
	    public T queryOne(T record) {
	        return this.mapper.selectOne(record);
	    }

	    /**
	     * 根据实体字段条件查询数据列表
	     * 
	     * @param record
	     * @return
	     */
	    public List<T> queryListByWhere(T record) {
	        return this.mapper.select(record);
	    }

	    /**
	     * 根据实体字段条件分页查询
	     * 
	     * @param page
	     * @param rows
	     * @param record
	     * @return
	     */
	    public PageInfo<T> queryPageListByWhere(Integer page, Integer rows, T record) {
	        // 设置分页条件
	        PageHelper.startPage(page, rows);
	        List<T> list = this.queryListByWhere(record);
	        return new PageInfo<T>(list);
	    }
	    
	    /**
	     * 
	        * @Title: queryListByProperty
	        * @Description: TODO(根据实体字段集合名(List<Object>)查询数据)
	        * @param @param clazz
	        * @param @param property
	        * @param @param values
	        * @param @return    参数
	        * @return List<T>    返回类型
	        * @throws
	     */
	    public List<T> queryListByProperty(Class<T> clazz, String property, List<Object> values) {
	    	if(values.size()==0){
	    		return null;
	    	}
	        Example example = new Example(clazz);
	        example.createCriteria().andIn(property, values);
	        List<T> list = this.mapper.selectByExample(example);
	        return list;
	    }
	    
	    /**
	     * 
	        * @Title: queryPageListByProperty
	        * @Description: TODO(根据实体字段集合名(List<Object>)分页查询数据)
	        * @param @param clazz
	        * @param @param property
	        * @param @param values
	        * @param @param page
	        * @param @param rows
	        * @param @return    参数
	        * @return PageInfo<T>    返回类型
	        * @throws
	     */
	    public PageInfo<T> queryPageListByProperty(Class<T> clazz, String property, List<Object> values,Integer page, Integer rows) {
	    	if(values.size()==0){
	    		return null;
	    	}
	    	Example example = new Example(clazz);
	        example.createCriteria().andIn(property, values);
	        PageHelper.startPage(page, rows);
	        List<T> list = this.mapper.selectByExample(example);
	        return new PageInfo<T>(list);
	    }
	    
	    /**
	     * 
	        * @Title: queryPageListByPropertyAndByClause
	        * @Description: TODO(根据实体字段集合名(List<Object>)和排序规则(字段名  desc/asc)分页查询数据)
	        * @param @param clazz
	        * @param @param property1
	        * @param @param values
	        * @param @param property2
	        * @param @param page
	        * @param @param rows
	        * @param @return    参数
	        * @return PageInfo<T>    返回类型
	        * @throws
	     */
	    public PageInfo<T> queryPageListByPropertyAndByClause(Class<T> clazz, String property1, List<Object> values,String property2,Integer page, Integer rows) {
	    	if(values.size()==0){
	    		return null;
	    	}
	    	Example example = new Example(clazz);
	        example.createCriteria().andIn(property1, values);
	        example.setOrderByClause(property2);
	        PageHelper.startPage(page, rows);
	        List<T> list = this.mapper.selectByExample(example);
	        return new PageInfo<T>(list);
	    }
	    

	    /**
	     * 新增数据，返回成功的条数
	     * 
	     * @param record
	     * @return
	     */
	    public Integer save(T record) {
			record.setCreated(new Date());
		    record.setUpdated(record.getCreated());
	        return this.mapper.insert(record);
	    }

	    /**
	     * 新增数据，使用不为null的字段，返回成功的条数
	     * 
	     * @param record
	     * @return
	     */
	    public Integer saveSelective(T record) {
		   record.setCreated(new Date());
	       record.setUpdated(record.getCreated());
	        return this.mapper.insertSelective(record);
	    }

	    /**
	     * 修改数据，返回成功的条数
	     * 
	     * @param record
	     * @return
	     */
	    public Integer update(T record) {
	    	record.setUpdated(new Date());
	        return this.mapper.updateByPrimaryKey(record);
	    }

	    /**
	     * 修改数据，使用不为null的字段，返回成功的条数
	     * 
	     * @param record
	     * @return
	     */
	    public Integer updateSelective(T record) {
			record.setUpdated(new Date());
			record.setCreated(null);
	        return this.mapper.updateByPrimaryKeySelective(record);
	    }

	    /**
	     * 根据id删除数据
	     * 
	     * @param id
	     * @return
	     */
	    public Integer deleteById(Long id) {
	        return this.mapper.deleteByPrimaryKey(id);
	    }

	    /**
	     * 批量删除
	     * @param clazz
	     * @param property
	     * @param values
	     * @return
	     */
	    public Integer deleteByIds(Class<T> clazz, String property, List<Object> values) {
	    	if(values.size()==0){
	    		return null;
	    	}
	        Example example = new Example(clazz);
	        example.createCriteria().andIn(property, values);
	        return this.mapper.deleteByExample(example);
	    }
	    
	    /**
	     * 根据条件做删除
	     * 
	     * @param record
	     * @return
	     */
	    public Integer deleteByWhere(T record) {
	        return this.mapper.delete(record);
	    }


		/**
		 * 通过selectProperties方法指定查询列
		 * @param
		 * @return
		 */
		public List<T> queryByProperties(Class<T> clazz, String properties[]) {
			Example example = new Example(clazz);
			example.createCriteria();
			example.selectProperties(properties);
			List<T> list=mapper.selectByExample(example);
			return list;
		}

}
